/*******************************************************************************
/
/ svideo.h
/
/ Creado por Roberto García Carvajal.
/
/ Incluye un gestor de menús muy simple (los menú de compras son poco
/ poco parametrizables y dejan mucho que desear, al igual que el de mapas).
/
/ La gestión de imagenes la realiza mediante un vector, para que sea más fácil
/ indizarlos.
/
/ El gestor de colisiones consta de 2 partes principalmente, un gestor que
/ las detecta en los menús y otro que lo detecta en batalla.
/
/ Documento bajo licencia GPL.
/
*******************************************************************************/

#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include <queue>
#include <vector>
#include <list>
#include "gui.h"
#include "svideo-m.h"
#include "Tecnologias.h"
#include "Personajes.h"
#include "gtec.h"
#include "guni.h"
#include "mapa.h"
#include "tablero.h"

#ifndef _C_SVIDEO_
#define _C_SVIDEO_


// Declaraciones adelantadas.
class c_nucleo;
class c_sentrada;
class c_sred;
class c_ssonido;

class c_svideo
{
 public:
  // Constructor
  c_svideo();
  // Métodos para realizar las asociaciones binarias.
  void asociar_nucleo(c_nucleo * n) { nucleo = n; }
  void asociar_sentrada(c_sentrada * e) { sentrada = e; }
  void asociar_sred(c_sred * r) { sred = r; }
  void asociar_ssonido(c_ssonido * s) { ssonido = s; }
  // Método para recoger mensajes del exterior (y el interior).
  void nuevomensaje(c_sv_mensaje m) { mensajes.push(m); }
  // Método para detectar las colisiones de ratón al hacer click
  void colision(unsigned int x,unsigned int y);
  // Método para dejar de dibujar.
  void decolision();
  // Método para cambiar a pantalla completa.
  void pantallacompleta();
  // Método para añadir texto.
  void acaracter(char m);
  // Método para borrar texto.
  void bcaracter();
  // Ciclo de vídeo, para el gameloop.
  void ciclo();
  // Método para cambiar a menús.
  void cambiomenus();
  // Método para cambiar a batalla.
  void cambiojuego();
  
  void elegirmapas();
  // Método para recibir un mensaje del jugador remoto.
  void mensajeremoto(char * mens);
  // Método para recibir un movimiento de un personaje remoto.
  void movimiento_enemigo(unsigned int unidad, unsigned int ddestino);
  void mapaelegido(c_mapa mapae);
  void jugador_local(int ejer,vector<personaje> p,vector<coordenada> c);
  void jugador_remoto(int ejer,vector<personaje> p,vector<coordenada> c);
  SDL_Surface * ataque_local(int idg_atacante,int idg_defensor);
  void movimiento_local(int idg,int x,int y,int movrestante);
  void movimiento_remoto(int idg,int x,int y);
  void ataque_remoto(int idg,int dano);
  void elimina_unidad_local(int idg);
  void elimina_unidad_remota(int idg);
  void restaurar_movimiento();
  void fin_batalla(int f);
  void vida(unsigned int idg,unsigned int t);
 private:
  // Punteros a los otros subsistemas.
  c_nucleo * nucleo;
  c_sentrada * sentrada;
  c_sred * sred;
  c_ssonido * ssonido;
  // Cola de mensajes con órdenes.
  std::queue<c_sv_mensaje> mensajes;
  // Cursor seleccionado
  unsigned int ncursor;
  // Cursores.
  SDL_Surface * cursor[2];

  int resultado;
  // Copia interna de los menus,
  SDL_Surface * pantallamenu;
  // Generador de pantallamenu;
  void pregenerar_menu();
  // Pantalla
  SDL_Surface * pantalla;
  // Número de imágenes cargadas.
  unsigned int nimagenes;
  // Vector de imágenes.
  SDL_Surface ** imagen;
  // Vector de imágenes para el texto.
  SDL_Surface ** texto;
  // Vector de menús.
  c_objeto_gui *** gui;
  // Para saber si se está en modo menú o en modo batalla.
  // Vector con contadores de objetos de menú.
  unsigned int *nogui;
  // Menú en visualización.
  unsigned int uigui;
  // Vector de fuentes.
  TTF_Font ** fuente;
  // Número de fuentes.
  unsigned int nfuentes;
  // Para saber si se está en modo pantalla completa.
  // Para conocer el objeto de menú en el que se escribirá.
  unsigned int objetivoescritura;
  // Para renderizar la cantidad de dinero.
  SDL_Surface * dinero;
  // Métodos para revisar las compras.
  void revisarcomprastec(int ejercito);
  void revisarcomprasuni(int ejercito);
  // Vector para almacenar las compras
  vector<int> compra;
  // Indica la compra en visualización.
  unsigned int compraactual;
  // Vectores de estructuras para las imagenes de las compras.
  c_gtec ** gtec;
  c_guni ** guni;
  // Vectores para las texturas de los personajes (logos).
  SDL_Surface ** UP;
  SDL_Surface ** UI;
  // Vector de tiles.
  SDL_Surface ** tile;
  // Vector de personajes en juego (locales y remotos) y sus coordenadas.
  vector<personaje> pl,pr;
  vector<pair<int,int> > cpl,cpr;
  
  vector<char*> MD5;
  vector<SDL_Surface*> texto_mapas;

  // Banderas para las opciones.
  unsigned int FLAGS;

  

  // Vector de posibles movimientos.
  vector<int> posicionesposibles;

  // Métodos que comprueban si en una posición del tablero hay una unidad.
  unsigned int buscarunidadlocal(int x,int y);
  unsigned int buscarunidadremota(int x,int y);

  // Modo de juego.
  int modo;

  // Describe si hay unidades en movimiento (locales o remotas).
  // Y cuál es.
  int unidadenmovimiento;
  // Parámetros de los movimientos.
  int destino,tipo,xd,xa,yd,ya;
  // Posiciones del mapa
  unsigned int posmapax,posmapay;

  // Para renderizar los mensajes en batalla.
  char * ndialogo;
  SDL_Surface * Sndialogo;
  list<SDL_Surface*> dialogo;
  int contador_n_mensaje;

  // Método cambiador de menús.
  void cambiargui(unsigned int i);
  // Método lanzador de instrucciones.
  void lanzar(c_objeto_gui * cog);
  
  c_mapa mapa;
  c_tablero tablero;
  SDL_Surface * vvida;
};

#endif
